diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index d03fab5..e11bdc7 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -71,7 +71,8 @@
 	<li>Reorganized the URI and Routes classes for better clarity.</li>
     <li>Javascript Calendar plugin now uses the months and days from the calendar language file, instead of hard-coded values, internationalizing it </li>
     <li>Removed &quot;rand()&quot; as a listed option from orderby in the <a href="./database/active_record.html">Active Record</a>, as it was MySQL only. </li>
-    <li>Added titles to all user manual pages </li>
+    <li>Added titles to all user manual pages</li>
+    <li>Documented the timezones() function in the <a href="./helpers/date_helper.html">Date Helper</a></li>
     <li>Fixed a bug in database driver where num_rows property wasn't getting updated </li>
     <li>Fixed a bug in captcha calling an invalid PHP function</li>
 	<li>Fixed a bug in _html_entity_decode_callback() when 'global_xss_filtering' is enabled.</li>
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index d703801..2353ff8 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -223,11 +223,11 @@
 <code>echo days_in_month(06, 2005);</code>
 
 <p>If the second parameter is empty, the current year will be used.</p>
-
-
-
+<h2>timezones()</h2>
+<p> Takes a timezone reference (for a list of valid timezones, see the &quot;Timezone Reference&quot; below) and returns the number of hours offset from UTC.</p>
+<p><code>echo timezones('UM5');</code></p>
+<p>This function is useful when used with timezone_menu(). </p>
 <h2>timezone_menu()</h2>
-
 <p>Generates a pull-down menu of timezones, like this one:</p>
 
 <form>
